#include <stdio.h>
#include <assert.h>

#include "grphoal.h"

namespace grphoal
{

#ifndef TEST_DBG_WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <limits.h>
#include <fcntl.h>
#include <string.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <errno.h>
#endif

syncobject::syncobject()
#ifndef TEST_DBG_WIN32
: LockCount(0)
, ThreadID(0)
#endif
{
#ifdef TEST_DBG_WIN32
	::InitializeCriticalSection(&cs);
#else
	if (sem_init(&sem, 0, 1))
		assert(0);
#endif
}

syncobject::~syncobject()
{
#ifdef TEST_DBG_WIN32
	::DeleteCriticalSection(&cs);
#else
	if (sem_destroy(&sem))
		assert(0);
#endif
}

void syncobject::sync_start(void)
{			
#ifdef TEST_DBG_WIN32
	::EnterCriticalSection(&cs);
#else
	if (!ThreadID)
	{
		assert(!LockCount);
		sem_wait(&sem);
		ThreadID = oal::GetThreadID();
	}
	else
	{
		if (oal::GetThreadID() == ThreadID)
		{
			// ÏàÍ¬µÄÏß³Ì½øÈë£¬²»Ëø£¨²Î¿¼WindowsÉè¼Æ£©
			LockCount++;
		}
		else
		{
			sem_wait(&sem);
			// Ó¦¸Ã²»»á³É¹¦½øÈë£¬µ«Èç¹û½øÈëÁË£¬ÄÇÃ´¸üÐÂThreadID
			ThreadID = oal::GetThreadID();
		}
	}
#endif
}

bool syncobject::sync_start(bool blTrySync)
{
	bool blRet = true;
	if (blTrySync == true) {
#ifdef TEST_DBG_WIN32
		blRet = ::TryEnterCriticalSection(&cs) ? true : false;
#else
		if (!ThreadID)
		{
			assert(!LockCount);
			blRet = (sem_trywait(&sem) == EAGAIN)	? false : true;
			if (blRet) ThreadID = oal::GetThreadID();
		}
		else
		{
			if (oal::GetThreadID() == ThreadID)
			{
				// ÏàÍ¬µÄÏß³Ì½øÈë£¬²»Ëø£¨²Î¿¼WindowsÉè¼Æ£©
				LockCount++;
			}
			else
			{
				blRet = (sem_trywait(&sem) == EAGAIN)	? false : true;
				// Ó¦¸Ã²»»á³É¹¦½øÈë£¬µ«Èç¹û½øÈëÁË£¬ÄÇÃ´¸üÐÂThreadID
				if (blRet) ThreadID = oal::GetThreadID();
			}
		}
#endif
	}
	else{
		sync_start();
	}
	return blRet;
}

void syncobject::sync_end(void)
{			
#ifdef TEST_DBG_WIN32
	::LeaveCriticalSection(&cs);
#else
	if (!ThreadID) return;
	if (LockCount > 0) --LockCount;
	else
	{
		ThreadID = 0;
		sem_post(&sem);
	}
#endif
}

autosync::autosync(syncobject &syncobj) {
	m_syncobj = &syncobj;
	syncobj.sync_start();
}

autosync::~autosync() {
	assert(NULL != m_syncobj);
	m_syncobj->sync_end();
}


uint str2id(const char* name)
{
	uint s, i;
	for (s = i = 0; name[i]; i++)
		s = (s + (i + 1) * name[i]) % 0x8000000bu * 0xffffffefu;
	return s ^ 0x12345678;
}

shared_memory::shared_memory()
#ifdef TEST_DBG_WIN32
: m_Handle(NULL)
#else
: m_Handle(-1)
#endif
, m_pAddr(NULL), m_Length(0), m_IsCreator(false)
{
}

shared_memory::shared_memory(const char *name, size_t num_pages)
#ifdef TEST_DBG_WIN32
: m_Handle(NULL)
#else
: m_Handle(-1)
#endif
, m_pAddr(NULL), m_Length(num_pages * PAGE_SIZE), m_IsCreator(false)
{
	attach(name, num_pages);
}

bool shared_memory::try_attach(const char *name, size_t num_pages)
{
	if (NULL == name) return false;

#ifdef TEST_DBG_WIN32
	m_Handle = OpenFileMapping(FILE_MAP_ALL_ACCESS,
		true, name);

	if (NULL != m_Handle)
	{
		m_pAddr = MapViewOfFile(m_Handle, FILE_MAP_ALL_ACCESS,
			0, 0, 0);
		m_Length = num_pages * PAGE_SIZE;
		return true;
	}
	return false;

#else
	uint key = Str2ID(name);
	m_Handle = shmget(key, num_pages * PAGE_SIZE, IPC_CREAT | IPC_EXCL | 0666);
	if (INT(m_Handle) >= 0)
	{
		shmctl(m_Handle, IPC_RMID, 0);
		m_Handle = -1;
		return false;
	}
	else
	{
		m_Handle = shmget(key, num_pages * PAGE_SIZE, IPC_CREAT | 0666);
		Output("shared_memory::Tryattach m_Handle [%d]\n", (uint)m_Handle);
		if (m_Handle < 0) { m_pAddr = NULL;return false; }
		m_pAddr = shmat((int)m_Handle, (void *) 0, 0);
		m_Length = num_pages * PAGE_SIZE;
		return true;
	}
	return false;

#endif
}

void shared_memory::assign_to(shared_memory& sharedMem)
{
	sharedMem.detach();
	sharedMem.m_Handle = m_Handle;
	sharedMem.m_pAddr = m_pAddr;
	sharedMem.m_IsCreator = m_IsCreator;

#ifdef TEST_DBG_WIN32
	assert(NULL != sharedMem.m_Handle);
	m_Handle = NULL;
#else
	assert(sharedMem.m_Handle >= 0);
	m_Handle = -1;
#endif
	m_pAddr = NULL;
	m_IsCreator = false;

	sharedMem.attach((const char *)(1), m_Length / PAGE_SIZE);
	m_Length = 0;
}

void* shared_memory::address(void) const { return m_pAddr; }
uint shared_memory::length(void) const { return m_Length; }
bool shared_memory::is_creator(void) { return m_IsCreator; }


void shared_memory::attach(const char *name, size_t num_pages)
{
	if (NULL == name) return;

#ifdef TEST_DBG_WIN32

	if (NULL == m_Handle)
	{
		m_Handle = OpenFileMapping(FILE_MAP_ALL_ACCESS,
			true, name);

		if (NULL == m_Handle)
		{
			m_Handle = CreateFileMapping((PVOID)0xFFFFFFFF, NULL,
				PAGE_READWRITE, 0, num_pages * PAGE_SIZE, name);
			if (NULL == m_Handle) { m_pAddr = NULL; return; }
			m_IsCreator = true;
		}
	}
	m_pAddr = MapViewOfFile(m_Handle, FILE_MAP_ALL_ACCESS,
		0, 0, 0);

#else
	bool log = false;
	if (m_Handle < 0)
	{
		uint key = Str2ID(name);
		m_Handle = shmget(key, num_pages * PAGE_SIZE, IPC_CREAT | IPC_EXCL | 0666);
		if (INT(m_Handle) >= 0)
		{
			log = true;
			m_IsCreator = true;
		}
		else
		{
			m_Handle = shmget(key, num_pages * PAGE_SIZE, IPC_CREAT | 0666);
			if (m_Handle < 0) { m_pAddr = NULL;return; }
		}
	}
	m_pAddr = shmat((int)m_Handle, (void *) 0, 0);

	if (log)
		Trace("NShareMemory: attach %u pages to %X, BlockName: %s.\n", num_pages,(uint)m_pAddr, name);
#endif

	m_Length = num_pages * PAGE_SIZE;
}

shared_memory::~shared_memory()
{
	detach();
}

void shared_memory::detach(void)
{
#ifdef TEST_DBG_WIN32
	if (m_pAddr) UnmapViewOfFile(m_pAddr);
	if (m_Handle) CloseHandle(m_Handle);
#else
	if (m_pAddr) 
	{
		shmdt(m_pAddr);
	}
	if (m_IsCreator && m_Handle >= 0) shmctl(m_Handle, IPC_RMID, 0);
#endif

#ifdef TEST_DBG_WIN32
	m_Handle = NULL;
#else
	m_Handle = -1;
#endif

	m_pAddr  = NULL;
	m_IsCreator = false;
	m_Length = 0;
}

procsyncobject::procsyncobject()
: handle(NULL)
{}

procsyncobject::procsyncobject(LPCTSTR name)
: handle(NULL)
{
	if (name)
		create(name);
}

procsyncobject::~procsyncobject()
{
	destroy();
}

bool procsyncobject::create(const char* name)
{
	if (NULL == name) return false;

#ifdef TEST_DBG_WIN32

	if(handle != NULL) ::CloseHandle(handle);
	if((handle = ::CreateMutex(NULL, false, name)) == NULL) return false;
	return true;

#else

	if (NULL != handle) sem_close((sem_t*)handle);

	char tmp[NAME_MAX];
	if (strlen(name) > NAME_MAX - 14) return false;
	strcpy(tmp, "NAF_sync_");
	strcpy(tmp + 9, name);	// must be modified if "NAF_sync_" changed
	handle = (void*)sem_open(tmp, O_CREAT, 0666, 1);
	if (handle == (void*)SEM_FAILED) return false;
	return true;

#endif
}

void procsyncobject::destroy(void)
{
	if (NULL == handle)
		return;

#ifdef TEST_DBG_WIN32
	::CloseHandle(handle);
#else
	sem_close((sem_t*)handle);
#endif
	handle = NULL;
}

bool procsyncobject::sync_start(void) const
{
	if(handle == NULL) return false;

#ifdef TEST_DBG_WIN32

	if(::WaitForSingleObject(handle, INFINITE) == WAIT_OBJECT_0)
		return true;
	return false;

#else

	if (NULL == handle) return false;
	sem_wait((sem_t*)handle);
	return true;

#endif
}

void procsyncobject::sync_end() const
{
	if(handle == NULL) return;

#ifdef TEST_DBG_WIN32
	::ReleaseMutex(handle);
#else

	if (NULL == handle) return;
	sem_post((sem_t*)handle);

#endif
}

autoprocsync::autoprocsync(procsyncobject &SyncObj) {
	m_pSyncObj = &SyncObj;
	SyncObj.sync_start();
}

autoprocsync::~autoprocsync() {
	assert(NULL != m_pSyncObj);
	m_pSyncObj->sync_end();
}

namespace md5gen_imp
{
	#define R_memset(x, y, z) memset(x, y, z)
	#define R_memcpy(x, y, z) memcpy(x, y, z)
	#define R_memcmp(x, y, z) memcmp(x, y, z) 

	typedef unsigned long UINT4;
	typedef unsigned char *POINTER; 

	struct MD5_CTX
	{
	  UINT4 state[4];   
	  UINT4 count[2];
	  unsigned char buffer[64];  
	}; 

	void MD5Init(MD5_CTX *);
	void MD5Update(MD5_CTX *, unsigned char *, unsigned int);
	void MD5Final(unsigned char [16], MD5_CTX *); 

	#define S11 7
	#define S12 12
	#define S13 17
	#define S14 22
	#define S21 5
	#define S22 9
	#define S23 14
	#define S24 20
	#define S31 4
	#define S32 11
	#define S33 16
	#define S34 23
	#define S41 6
	#define S42 10
	#define S43 15
	#define S44 21 

	static void MD5Transform(UINT4 [4], unsigned char [64]);
	static void Encode(unsigned char *, UINT4 *, unsigned int);
	static void Decode(UINT4 *, unsigned char *, unsigned int); 

	static unsigned char PADDING[64] = {
	  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	}; 

	#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
	#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
	#define H(x, y, z) ((x) ^ (y) ^ (z))
	#define I(x, y, z) ((y) ^ ((x) | (~z))) 

	#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) 

	#define FF(a, b, c, d, x, s, ac) { \
	  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
	  (a) = ROTATE_LEFT ((a), (s)); \
	  (a) += (b); \
	 }
	#define GG(a, b, c, d, x, s, ac) { \
	  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
	  (a) = ROTATE_LEFT ((a), (s)); \
	  (a) += (b); \
	 }
	#define HH(a, b, c, d, x, s, ac) { \
	  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
	  (a) = ROTATE_LEFT ((a), (s)); \
	  (a) += (b); \
	 }
	#define II(a, b, c, d, x, s, ac) { \
	  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
	  (a) = ROTATE_LEFT ((a), (s)); \
	  (a) += (b); \
	 } 

	void MD5Init (MD5_CTX *context)
	{
	  context->count[0] = context->count[1] = 0; 

	  context->state[0] = 0x67452301;
	  context->state[1] = 0xefcdab89;
	  context->state[2] = 0x98badcfe;
	  context->state[3] = 0x10325476;
	} 

	void MD5Update(MD5_CTX *context,unsigned char * input,unsigned int  inputLen)
	{
	 unsigned int i, index, partLen; 

	 index = (unsigned int)((context->count[0] >> 3) & 0x3F); 

	 if((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))
	  context->count[1]++;
	 context->count[1] += ((UINT4)inputLen >> 29); 
	 partLen = 64 - index; 

	 if(inputLen >= partLen) 
	 {
	  R_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
	  MD5Transform(context->state, context->buffer); 
	  for(i = partLen; i + 63 < inputLen; i += 64 )
	   MD5Transform(context->state, &input[i]); 

			index = 0;
		}
		else
	  i = 0; 

	 /* Buffer remaining input */
	 R_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
	} 

	void MD5Final (unsigned char digest[16],MD5_CTX *context)
	{
	 unsigned char bits[8];
	 unsigned int index, padLen; 

	 /* Save number of bits */
	 Encode(bits, context->count, 8); 

	 index = (unsigned int)((context->count[0] >> 3) & 0x3f);
	 padLen = (index < 56) ? (56 - index) : (120 - index);
	 MD5Update(context, PADDING, padLen); 
	 MD5Update(context, bits, 8); 
	 Encode(digest, context->state, 16); 

	 R_memset((POINTER)context, 0, sizeof(*context));
	} 

	static void MD5Transform (UINT4 state[4], unsigned char block[64])
	{
	 UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; 

	 Decode(x, block, 64); 

	 /* Round 1 */
	 FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
	 FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
	 FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
	 FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
	 FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
	 FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
	 FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
	 FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
	 FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
	 FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
	 FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
	 FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
	 FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
	 FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
	 FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
	 FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ 

	 /* Round 2 */ 
	 GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
	 GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
	 GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
	 GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
	 GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
	 GG(d, a, b, c, x[10], S22,  0x2441453); /* 22 */
	 GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
	 GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
	 GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
	 GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
	 GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
	 GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
	 GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
	 GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
	 GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
	 GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ 

	 /* Round 3 */ 
	 HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
	 HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
	 HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
	 HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
	 HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
	 HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
	 HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
	 HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
	 HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
	 HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
	 HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
	 HH(b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
	 HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
	 HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
	 HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
	 HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ 

	 /* Round 4 */
	 II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
	 II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
	 II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
	 II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
	 II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
	 II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
	 II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
	 II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
	 II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
	 II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
	 II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
	 II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
	 II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
	 II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
	 II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
	 II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ 

	 state[0] += a;
	 state[1] += b;
	 state[2] += c;
	 state[3] += d; 

	 /* Zeroize sensitive information. */
	 R_memset((POINTER)x, 0, sizeof(x));
	} 

	/* Encodes input (UINT4) into output (unsigned char). Assumes len is
	  a multiple of 4. */
	static void Encode(unsigned char *output, UINT4 *input,unsigned int  len)
	{
	 unsigned int i, j; 

	 for(i = 0, j = 0; j < len; i++, j += 4) {
	  output[j] = (unsigned char)(input[i] & 0xff);
	  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
	  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
	  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
	 }
	} 

	/* Decodes input (unsigned char) into output (UINT4). Assumes len is
	  a multiple of 4. */
	static void Decode(UINT4 *output, unsigned char *input,unsigned int  len)
	{
	 unsigned int i, j; 

	 for(i = 0, j = 0; j < len; i++, j += 4)
	  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
	   (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
	} 
};

md5gen::md5gen()
: m_pMd5(NULL)
{
	m_pMd5 = new md5gen_imp::MD5_CTX;
	assert(NULL != m_pMd5);
	MD5Init(m_pMd5);
}

md5gen::md5gen(void *pData, size_t sz)
: m_pMd5(NULL)
{
	m_pMd5 = new md5gen_imp::MD5_CTX;
	assert(NULL != m_pMd5);
	MD5Init(m_pMd5);

	memset(&m_Result, 0, sizeof(m_Result));
	if (NULL == pData || 0 == sz)
		return;

	MD5Update(m_pMd5, (BYTE*)pData, sz);
	MD5Final((BYTE *)&m_Result, m_pMd5);
}

md5gen::~md5gen()
{
	if (m_pMd5)
		delete m_pMd5;
}

void md5gen::encode(void* pData, size_t sz)
{
	if (NULL == pData || 0 == sz)
	{
		memset(&m_Result, 0, sizeof(m_Result));
		return;
	}

	MD5Init(m_pMd5);
	MD5Update(m_pMd5, (BYTE*)pData, sz);
	MD5Final((BYTE *)&m_Result, m_pMd5);
}


}; // namespace grphoal
/* EOF */
